home *** CD-ROM | disk | FTP | other *** search
/ Amiga Format CD 42 / Amiga Format AFCD42 (Issue 126, Aug 1999).iso / -serious- / programming / other / jikes / src / control.h < prev    next >
C/C++ Source or Header  |  1999-05-14  |  11KB  |  379 lines
  1. // $Id: control.h,v 1.6 1999/02/12 14:39:11 shields Exp $
  2. //
  3. // This software is subject to the terms of the IBM Jikes Compiler
  4. // License Agreement available at the following URL:
  5. // http://www.ibm.com/research/jikes.
  6. // Copyright (C) 1996, 1998, International Business Machines Corporation
  7. // and others.  All Rights Reserved.
  8. // You must accept the terms of that agreement to use this software.
  9. //
  10. #ifndef control_INCLUDED
  11. #define control_INCLUDED
  12.  
  13. #include "config.h"
  14. #include <iostream.h>
  15. #include <stdio.h>
  16. #include "option.h"
  17. #include "symbol.h"
  18. #include "tuple.h"
  19. #include "set.h"
  20.  
  21. class StoragePool;
  22. class Scanner;
  23. class Parser;
  24. class Semantic;
  25. class LexStream;
  26. class AstPackageDeclaration;
  27.  
  28. class Control : public StringConstant
  29. {
  30. public:
  31.     int return_code;
  32.     Option &option;
  33.     SymbolTable classpath_table,
  34.                 external_table;
  35.     PackageSymbol *system_package,
  36.                   *unnamed_package;
  37.     int dot_classpath_index;
  38.     Tuple<PathSymbol *> classpath;
  39.     Tuple<DirectorySymbol *> root_directories;
  40.     Tuple<wchar_t *> bad_zip_filenames,
  41.                      bad_input_filenames,
  42.                      unreadable_input_filenames;
  43.                      
  44.     Semantic *system_semantic;
  45.     Tuple<Semantic *> semantic;
  46.     Tuple<TypeSymbol *> needs_body_work,
  47.                         type_trash_bin;
  48.  
  49.     SymbolMap unnamed_package_types;
  50.  
  51.     SymbolSet input_java_file_set,
  52.               input_class_file_set,
  53.               expired_file_set,
  54.               recompilation_file_set;
  55.  
  56.     Parser *parser;
  57.     Scanner *scanner;
  58.  
  59.     //
  60.     //
  61.     //
  62.     LiteralLookupTable string_table,
  63.                        int_table,
  64.                        long_table,
  65.                        char_table,
  66.                        float_table,
  67.                        double_table;
  68.     NameLookupTable name_table;
  69.  
  70.     //
  71.     //
  72.     //
  73.     NameSymbol *dot_name_symbol,
  74.                *dot_dot_name_symbol,
  75.                *length_name_symbol,
  76.                *init_name_symbol,
  77.                *clinit_name_symbol,
  78.                *block_init_name_symbol,
  79.                *this0_name_symbol,
  80.                *clone_name_symbol,
  81.                *object_name_symbol,
  82.                *type_name_symbol,
  83.                *class_name_symbol;
  84.  
  85.     //
  86.     //
  87.     //
  88.     TypeSymbol *byte_type,
  89.                *short_type,
  90.                *int_type,
  91.                *long_type,
  92.                *char_type,
  93.                *float_type,
  94.                *double_type,
  95.                *boolean_type,
  96.                *void_type,
  97.                *null_type,
  98.                *no_type,
  99.  
  100.                *Serializable_type,
  101.  
  102.                *Object_type,
  103.                *Cloneable_type,
  104.                *String_type,
  105.                *Void_type,
  106.                *Boolean_type,
  107.                *Byte_type,
  108.                *Short_type,
  109.                *Character_type,
  110.                *Integer_type,
  111.                *Long_type,
  112.                *Float_type,
  113.                *Double_type,
  114.                *Class_type,
  115.                *StringBuffer_type,
  116.                *Throwable_type,
  117.                *RuntimeException_type,
  118.                *Error_type;
  119.     //
  120.     TypeSymbol *GetType(PackageSymbol *, wchar_t *);
  121.  
  122.     inline TypeSymbol *Serializable()
  123.     {
  124.         if ((! Serializable_type) && option.one_one)
  125.         {
  126.             PackageSymbol *io_package = ProcessPackage(StringConstant::US_java_SL_io);
  127.             FindPathsToDirectory(io_package);
  128.             Serializable_type = GetType(io_package, StringConstant::US_Serializable);
  129.         }
  130.  
  131.         return Serializable_type;
  132.     }
  133.  
  134.     inline TypeSymbol *Object()
  135.     {
  136.         return (Object_type ? Object_type : Object_type = GetType(system_package, StringConstant::US_Object));
  137.     }
  138.  
  139.     inline TypeSymbol *Cloneable()
  140.     {
  141.         return (Cloneable_type ? Cloneable_type : Cloneable_type = GetType(system_package, StringConstant::US_Cloneable));
  142.     }
  143.  
  144.     inline TypeSymbol *String()
  145.     {
  146.         return (String_type ? String_type : String_type = GetType(system_package, StringConstant::US_String));
  147.     }
  148.  
  149.     inline TypeSymbol *Void()
  150.     {
  151.         return (Void_type ? Void_type : Void_type = GetType(system_package, StringConstant::US_Void));
  152.     }
  153.  
  154.     inline TypeSymbol *Boolean()
  155.     {
  156.         return (Boolean_type ? Boolean_type : Boolean_type = GetType(system_package, StringConstant::US_Boolean));
  157.     }
  158.  
  159.     inline TypeSymbol *Byte()
  160.     {
  161.         return (Byte_type ? Byte_type : Byte_type = GetType(system_package, StringConstant::US_Byte));
  162.     }
  163.  
  164.     inline TypeSymbol *Short()
  165.     {
  166.         return (Short_type ? Short_type : Short_type = GetType(system_package, StringConstant::US_Short));
  167.     }
  168.  
  169.     inline TypeSymbol *Character()
  170.     {
  171.         return (Character_type ? Character_type : Character_type = GetType(system_package, StringConstant::US_Character));
  172.     }
  173.  
  174.     inline TypeSymbol *Integer()
  175.     {
  176.         return (Integer_type ? Integer_type : Integer_type = GetType(system_package, StringConstant::US_Integer));
  177.     }
  178.  
  179.     inline TypeSymbol *Long()
  180.     {
  181.         return (Long_type ? Long_type : Long_type = GetType(system_package, StringConstant::US_Long));
  182.     }
  183.  
  184.     inline TypeSymbol *Float()
  185.     {
  186.         return (Float_type ? Float_type : Float_type = GetType(system_package, StringConstant::US_Float));
  187.     }
  188.  
  189.     inline TypeSymbol *Double()
  190.     {
  191.         return (Double_type ? Double_type : Double_type = GetType(system_package, StringConstant::US_Double));
  192.     }
  193.  
  194.     inline TypeSymbol *Class()
  195.     {
  196.         return (Class_type ? Class_type : Class_type = GetType(system_package, StringConstant::US_Class));
  197.     }
  198.  
  199.     inline TypeSymbol *StringBuffer()
  200.     {
  201.         return (StringBuffer_type ? StringBuffer_type
  202.                                   : StringBuffer_type = GetType(system_package, StringConstant::US_StringBuffer));
  203.     }
  204.  
  205.     inline TypeSymbol *Throwable()
  206.     {
  207.         return (Throwable_type ? Throwable_type : Throwable_type = GetType(system_package, StringConstant::US_Throwable));
  208.     }
  209.  
  210.     inline TypeSymbol *RuntimeException()
  211.     {
  212.         return (RuntimeException_type
  213.                        ? RuntimeException_type
  214.                        : RuntimeException_type = GetType(system_package, StringConstant::US_RuntimeException));
  215.     }
  216.  
  217.     inline TypeSymbol *Error()
  218.     {
  219.         return (Error_type ? Error_type : Error_type = GetType(system_package, StringConstant::US_Error));
  220.     }
  221.  
  222.     //
  223.     //
  224.     //
  225.     LiteralValue bad_value;
  226.  
  227.     IntLiteralTable    int_pool;
  228.     LongLiteralTable   long_pool;
  229.     FloatLiteralTable  float_pool;
  230.     DoubleLiteralTable double_pool;
  231.     Utf8LiteralTable   Utf8_pool;
  232.  
  233.     Control(ArgumentExpander &, Option &);
  234.     ~Control();
  235.  
  236.     Utf8LiteralValue *ConvertUnicodeToUtf8(wchar_t *source)
  237.     {
  238.         char *target = new char[wcslen(source) * 3 + 1]; // should be big enough for the worst case
  239.         int length = ConvertUnicodeToUtf8(source, target);
  240.         Utf8LiteralValue *literal = Utf8_pool.FindOrInsert(target, length);
  241.         delete [] target;
  242.  
  243.         return literal;
  244.     }
  245.  
  246.     void FindPathsToDirectory(PackageSymbol *);
  247.  
  248.     DirectoryEntry *FindInputFile(FileSymbol *);
  249.     void FindMoreRecentInputFiles(SymbolSet &);
  250.     void RemoveTrashedTypes(SymbolSet &);
  251.     void RereadDirectory(DirectorySymbol *);
  252.     void RereadDirectories();
  253.     void ComputeRecompilationSet(TypeDependenceChecker &);
  254.     bool IncrementalRecompilation();
  255.  
  256.     //
  257.     // The one and only null value constant.
  258.     //
  259.     LiteralValue *NullValue() { return &null_value; }
  260.  
  261.     //
  262.     // Note that only names are converted here and not literals, since
  263.     // no error can occur in a name.
  264.     // A literal is converted during the semantic pass so that an
  265.     // accurate diagnostic can be issued in case it is invalid.
  266.     //
  267.     NameSymbol *FindOrInsertName(wchar_t *name, int len)
  268.     {
  269.         NameSymbol *name_symbol = name_table.FindOrInsertName(name, len);
  270.         if (! name_symbol -> Utf8_literal)
  271.             name_symbol -> Utf8_literal = ConvertUnicodeToUtf8(name_symbol -> Name());
  272.  
  273.         return name_symbol;
  274.     }
  275.  
  276.     //
  277.     // Make up a parameter name of the form #(num) and return its name symbol.
  278.     //
  279.     NameSymbol *MakeParameter(int num)
  280.     {
  281.         wchar_t st